Struct core_simd::Simd [−][src]
#[repr(simd)]pub struct Simd<T, const LANES: usize>(_)
where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount;portable_simd)Expand description
A SIMD vector of LANES elements of type T.
Implementations
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)A const SIMD shuffle that takes 2 SIMD vectors and produces another vector, using the indices in the const parameter. The first or “self” vector will have its lanes indexed from 0, and the second vector will have its first lane indexed at $n. Indices must be in-bounds of either vector at compile time.
Some SIMD shuffle instructions can be quite slow, so avoiding them by loading data into the desired patterns in advance is preferred, but shuffles are still faster than storing and reloading from memory.
#![feature(portable_simd)]
let a = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
let b = Simd::from_array([5.0, 6.0, 7.0, 8.0]);
const IDXS: [u32; 4] = [4,0,3,7];
let c = Simd::<_, 4>::shuffle::<IDXS>(a,b);
assert_eq!(Simd::from_array([5.0, 1.0, 4.0, 8.0]), c);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Reverse the order of the lanes in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Interleave two vectors.
Produces two vectors with lanes taken alternately from self and other.
The first result contains the first LANES / 2 lanes from self and other,
alternating, starting with the first lane of self.
The second result contains the last LANES / 2 lanes from self and other,
alternating, starting with the lane LANES / 2 from the start of self.
This particular permutation is efficient on many architectures.
#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Deinterleave two vectors.
The first result takes every other lane of self and then other, starting with
the first lane.
The second result takes every other lane of self and then other, starting with
the second lane.
This particular permutation is efficient on many architectures.
#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)A const SIMD shuffle that takes 2 SIMD vectors and produces another vector, using the indices in the const parameter. The first or “self” vector will have its lanes indexed from 0, and the second vector will have its first lane indexed at $n. Indices must be in-bounds of either vector at compile time.
Some SIMD shuffle instructions can be quite slow, so avoiding them by loading data into the desired patterns in advance is preferred, but shuffles are still faster than storing and reloading from memory.
#![feature(portable_simd)]
let a = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
let b = Simd::from_array([5.0, 6.0, 7.0, 8.0]);
const IDXS: [u32; 4] = [4,0,3,7];
let c = Simd::<_, 4>::shuffle::<IDXS>(a,b);
assert_eq!(Simd::from_array([5.0, 1.0, 4.0, 8.0]), c);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Reverse the order of the lanes in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Interleave two vectors.
Produces two vectors with lanes taken alternately from self and other.
The first result contains the first LANES / 2 lanes from self and other,
alternating, starting with the first lane of self.
The second result contains the last LANES / 2 lanes from self and other,
alternating, starting with the lane LANES / 2 from the start of self.
This particular permutation is efficient on many architectures.
#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Deinterleave two vectors.
The first result takes every other lane of self and then other, starting with
the first lane.
The second result takes every other lane of self and then other, starting with
the second lane.
This particular permutation is efficient on many architectures.
#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)A const SIMD shuffle that takes 2 SIMD vectors and produces another vector, using the indices in the const parameter. The first or “self” vector will have its lanes indexed from 0, and the second vector will have its first lane indexed at $n. Indices must be in-bounds of either vector at compile time.
Some SIMD shuffle instructions can be quite slow, so avoiding them by loading data into the desired patterns in advance is preferred, but shuffles are still faster than storing and reloading from memory.
#![feature(portable_simd)]
let a = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
let b = Simd::from_array([5.0, 6.0, 7.0, 8.0]);
const IDXS: [u32; 4] = [4,0,3,7];
let c = Simd::<_, 4>::shuffle::<IDXS>(a,b);
assert_eq!(Simd::from_array([5.0, 1.0, 4.0, 8.0]), c);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Reverse the order of the lanes in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Interleave two vectors.
Produces two vectors with lanes taken alternately from self and other.
The first result contains the first LANES / 2 lanes from self and other,
alternating, starting with the first lane of self.
The second result contains the last LANES / 2 lanes from self and other,
alternating, starting with the lane LANES / 2 from the start of self.
This particular permutation is efficient on many architectures.
#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Deinterleave two vectors.
The first result takes every other lane of self and then other, starting with
the first lane.
The second result takes every other lane of self and then other, starting with
the second lane.
This particular permutation is efficient on many architectures.
#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)A const SIMD shuffle that takes 2 SIMD vectors and produces another vector, using the indices in the const parameter. The first or “self” vector will have its lanes indexed from 0, and the second vector will have its first lane indexed at $n. Indices must be in-bounds of either vector at compile time.
Some SIMD shuffle instructions can be quite slow, so avoiding them by loading data into the desired patterns in advance is preferred, but shuffles are still faster than storing and reloading from memory.
#![feature(portable_simd)]
let a = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
let b = Simd::from_array([5.0, 6.0, 7.0, 8.0]);
const IDXS: [u32; 4] = [4,0,3,7];
let c = Simd::<_, 4>::shuffle::<IDXS>(a,b);
assert_eq!(Simd::from_array([5.0, 1.0, 4.0, 8.0]), c);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Reverse the order of the lanes in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Interleave two vectors.
Produces two vectors with lanes taken alternately from self and other.
The first result contains the first LANES / 2 lanes from self and other,
alternating, starting with the first lane of self.
The second result contains the last LANES / 2 lanes from self and other,
alternating, starting with the lane LANES / 2 from the start of self.
This particular permutation is efficient on many architectures.
#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Deinterleave two vectors.
The first result takes every other lane of self and then other, starting with
the first lane.
The second result takes every other lane of self and then other, starting with
the second lane.
This particular permutation is efficient on many architectures.
#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)A const SIMD shuffle that takes 2 SIMD vectors and produces another vector, using the indices in the const parameter. The first or “self” vector will have its lanes indexed from 0, and the second vector will have its first lane indexed at $n. Indices must be in-bounds of either vector at compile time.
Some SIMD shuffle instructions can be quite slow, so avoiding them by loading data into the desired patterns in advance is preferred, but shuffles are still faster than storing and reloading from memory.
#![feature(portable_simd)]
let a = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
let b = Simd::from_array([5.0, 6.0, 7.0, 8.0]);
const IDXS: [u32; 4] = [4,0,3,7];
let c = Simd::<_, 4>::shuffle::<IDXS>(a,b);
assert_eq!(Simd::from_array([5.0, 1.0, 4.0, 8.0]), c);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Reverse the order of the lanes in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Interleave two vectors.
Produces two vectors with lanes taken alternately from self and other.
The first result contains the first LANES / 2 lanes from self and other,
alternating, starting with the first lane of self.
The second result contains the last LANES / 2 lanes from self and other,
alternating, starting with the lane LANES / 2 from the start of self.
This particular permutation is efficient on many architectures.
#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Deinterleave two vectors.
The first result takes every other lane of self and then other, starting with
the first lane.
The second result takes every other lane of self and then other, starting with
the second lane.
This particular permutation is efficient on many architectures.
#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal add. Returns the sum of the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal multiply. Returns the product of the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
Returns values based on equality, so a vector containing both 0. and -0. may
return either. This function will not return NaN unless all lanes are NaN.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
Returns values based on equality, so a vector containing both 0. and -0. may
return either. This function will not return NaN unless all lanes are NaN.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal add. Returns the sum of the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal multiply. Returns the product of the lanes of the vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal maximum. Returns the maximum lane in the vector.
Returns values based on equality, so a vector containing both 0. and -0. may
return either. This function will not return NaN unless all lanes are NaN.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Horizontal minimum. Returns the minimum lane in the vector.
Returns values based on equality, so a vector containing both 0. and -0. may
return either. This function will not return NaN unless all lanes are NaN.
impl<const LANES: usize> Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 1 * LANES } }>: SupportedLaneCount,
impl<const LANES: usize> Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 1 * LANES } }>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Return the memory representation of this integer as a byte array in native byte order.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Create a native endian integer value from its memory representation as a byte array in native endianness.
impl<const LANES: usize> Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 2 * LANES } }>: SupportedLaneCount,
impl<const LANES: usize> Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 2 * LANES } }>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Return the memory representation of this integer as a byte array in native byte order.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Create a native endian integer value from its memory representation as a byte array in native endianness.
impl<const LANES: usize> Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 4 * LANES } }>: SupportedLaneCount,
impl<const LANES: usize> Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 4 * LANES } }>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Return the memory representation of this integer as a byte array in native byte order.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Create a native endian integer value from its memory representation as a byte array in native endianness.
impl<const LANES: usize> Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 8 * LANES } }>: SupportedLaneCount,
impl<const LANES: usize> Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 8 * LANES } }>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Return the memory representation of this integer as a byte array in native byte order.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Create a native endian integer value from its memory representation as a byte array in native endianness.
impl<const LANES: usize> Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 8 * LANES } }>: SupportedLaneCount,
impl<const LANES: usize> Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 8 * LANES } }>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Return the memory representation of this integer as a byte array in native byte order.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Create a native endian integer value from its memory representation as a byte array in native endianness.
impl<const LANES: usize> Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 1 * LANES } }>: SupportedLaneCount,
impl<const LANES: usize> Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 1 * LANES } }>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Return the memory representation of this integer as a byte array in native byte order.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Create a native endian integer value from its memory representation as a byte array in native endianness.
impl<const LANES: usize> Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 2 * LANES } }>: SupportedLaneCount,
impl<const LANES: usize> Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 2 * LANES } }>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Return the memory representation of this integer as a byte array in native byte order.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Create a native endian integer value from its memory representation as a byte array in native endianness.
impl<const LANES: usize> Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 4 * LANES } }>: SupportedLaneCount,
impl<const LANES: usize> Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 4 * LANES } }>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Return the memory representation of this integer as a byte array in native byte order.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Create a native endian integer value from its memory representation as a byte array in native endianness.
impl<const LANES: usize> Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 8 * LANES } }>: SupportedLaneCount,
impl<const LANES: usize> Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 8 * LANES } }>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Return the memory representation of this integer as a byte array in native byte order.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Create a native endian integer value from its memory representation as a byte array in native endianness.
impl<const LANES: usize> Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 8 * LANES } }>: SupportedLaneCount,
impl<const LANES: usize> Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
LaneCount<{ { 8 * LANES } }>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Return the memory representation of this integer as a byte array in native byte order.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Create a native endian integer value from its memory representation as a byte array in native endianness.
impl<T, const LANES: usize> Simd<T, LANES> where
T: SimdElement + PartialEq,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Simd<T, LANES> where
T: SimdElement + PartialEq,
LaneCount<LANES>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Test if each lane is equal to the corresponding lane in other.
impl<T, const LANES: usize> Simd<T, LANES> where
T: SimdElement + PartialOrd,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Simd<T, LANES> where
T: SimdElement + PartialOrd,
LaneCount<LANES>: SupportedLaneCount,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Test if each lane is less than the corresponding lane in other.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Test if each lane is greater than the corresponding lane in other.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Test if each lane is less than or equal to the corresponding lane in other.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating add.
Examples
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(x - 1, unsat);
assert_eq!(sat, max);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating subtract.
Examples
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, x + 1);
assert_eq!(sat, Simd::splat(0));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating add.
Examples
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(x - 1, unsat);
assert_eq!(sat, max);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating subtract.
Examples
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, x + 1);
assert_eq!(sat, Simd::splat(0));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating add.
Examples
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(x - 1, unsat);
assert_eq!(sat, max);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating subtract.
Examples
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, x + 1);
assert_eq!(sat, Simd::splat(0));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating add.
Examples
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(x - 1, unsat);
assert_eq!(sat, max);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating subtract.
Examples
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, x + 1);
assert_eq!(sat, Simd::splat(0));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating add.
Examples
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(x - 1, unsat);
assert_eq!(sat, max);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating subtract.
Examples
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, x + 1);
assert_eq!(sat, Simd::splat(0));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating add.
Examples
let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating subtract.
Examples
let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.
Examples
let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.
Examples
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.
Examples
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating add.
Examples
let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating subtract.
Examples
let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.
Examples
let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.
Examples
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.
Examples
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating add.
Examples
let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating subtract.
Examples
let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.
Examples
let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.
Examples
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.
Examples
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating add.
Examples
let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating subtract.
Examples
let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.
Examples
let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.
Examples
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.
Examples
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating add.
Examples
let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating subtract.
Examples
let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.
Examples
let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.
Examples
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.
Examples
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns the smallest integer greater than or equal to each lane.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns the largest integer value less than or equal to each lane.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Rounds to the nearest integer value. Ties round toward zero.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns the floating point’s integer value, with its fractional part removed.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Rounds toward zero and converts to the same-width integer type, assuming that the value is finite and fits in that type.
Safety
The value must:
- Not be NaN
- Not be infinite
- Be representable in the return type, after truncating off its fractional part
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Creates a floating-point vector from an integer vector. Rounds values that are not exactly representable.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns the smallest integer greater than or equal to each lane.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns the largest integer value less than or equal to each lane.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Rounds to the nearest integer value. Ties round toward zero.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns the floating point’s integer value, with its fractional part removed.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Rounds toward zero and converts to the same-width integer type, assuming that the value is finite and fits in that type.
Safety
The value must:
- Not be NaN
- Not be infinite
- Be representable in the return type, after truncating off its fractional part
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Creates a floating-point vector from an integer vector. Rounds values that are not exactly representable.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Raw transmutation to an unsigned integer vector type with the same size and number of lanes.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Raw transmutation from an unsigned integer vector type with the same size and number of lanes.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Produces a vector where every lane has the absolute value of the
equivalently-indexed lane in self.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Fused multiply-add. Computes (self * a) + b with only one rounding error,
yielding a more accurate result than an unfused multiply-add.
Using mul_add may be more performant than an unfused multiply-add if the target
architecture has a dedicated fma CPU instruction. However, this is not always
true, and will be heavily dependent on designing algorithms with specific target
hardware in mind.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Produces a vector where every lane has the square root value
of the equivalently-indexed lane in self
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Takes the reciprocal (inverse) of each lane, 1/x.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Converts each lane from radians to degrees.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Converts each lane from degrees to radians.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if it has a positive sign, including
+0.0, NaNs with positive sign bit and positive infinity.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if it has a negative sign, including
-0.0, NaNs with negative sign bit and negative infinity.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if its value is NaN.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if its value is positive infinity or negative infinity.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if its value is neither infinite nor NaN.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if its value is subnormal.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if its value is neither neither zero, infinite,
subnormal, or NaN.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Replaces each lane with a number that represents its sign.
1.0if the number is positive,+0.0, orINFINITY-1.0if the number is negative,-0.0, orNEG_INFINITYNANif the number isNAN
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns each lane with the magnitude of self and the sign of sign.
If any lane is a NAN, then a NAN with the sign of sign is returned.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns the minimum of each lane.
If one of the values is NAN, then the other value is returned.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns the maximum of each lane.
If one of the values is NAN, then the other value is returned.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Restrict each lane to a certain interval unless it is NaN.
For each lane in self, returns the corresponding lane in max if the lane is
greater than max, and the corresponding lane in min if the lane is less
than min. Otherwise returns the lane in self.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Raw transmutation to an unsigned integer vector type with the same size and number of lanes.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Raw transmutation from an unsigned integer vector type with the same size and number of lanes.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Produces a vector where every lane has the absolute value of the
equivalently-indexed lane in self.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Fused multiply-add. Computes (self * a) + b with only one rounding error,
yielding a more accurate result than an unfused multiply-add.
Using mul_add may be more performant than an unfused multiply-add if the target
architecture has a dedicated fma CPU instruction. However, this is not always
true, and will be heavily dependent on designing algorithms with specific target
hardware in mind.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Produces a vector where every lane has the square root value
of the equivalently-indexed lane in self
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Takes the reciprocal (inverse) of each lane, 1/x.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Converts each lane from radians to degrees.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Converts each lane from degrees to radians.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if it has a positive sign, including
+0.0, NaNs with positive sign bit and positive infinity.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if it has a negative sign, including
-0.0, NaNs with negative sign bit and negative infinity.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if its value is NaN.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if its value is positive infinity or negative infinity.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if its value is neither infinite nor NaN.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if its value is subnormal.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each lane if its value is neither neither zero, infinite,
subnormal, or NaN.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Replaces each lane with a number that represents its sign.
1.0if the number is positive,+0.0, orINFINITY-1.0if the number is negative,-0.0, orNEG_INFINITYNANif the number isNAN
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns each lane with the magnitude of self and the sign of sign.
If any lane is a NAN, then a NAN with the sign of sign is returned.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns the minimum of each lane.
If one of the values is NAN, then the other value is returned.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns the maximum of each lane.
If one of the values is NAN, then the other value is returned.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Restrict each lane to a certain interval unless it is NaN.
For each lane in self, returns the corresponding lane in max if the lane is
greater than max, and the corresponding lane in min if the lane is less
than min. Otherwise returns the lane in self.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each positive lane and false if it is zero or negative.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each negative lane and false if it is zero or positive.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each positive lane and false if it is zero or negative.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each negative lane and false if it is zero or positive.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each positive lane and false if it is zero or negative.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each negative lane and false if it is zero or positive.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each positive lane and false if it is zero or negative.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each negative lane and false if it is zero or positive.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each positive lane and false if it is zero or negative.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns true for each negative lane and false if it is zero or positive.
impl<T, const LANES: usize> Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Construct a SIMD vector by setting all lanes to the given value.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns an array reference containing the entire SIMD vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Returns a mutable array reference containing the entire SIMD vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Converts an array to a SIMD vector.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)Converts a SIMD vector to an array.
🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)SIMD gather: construct a SIMD vector by reading from a slice, using potentially discontiguous indices. If an index is out of bounds, that lane instead selects the value from the “or” vector.
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);
let alt = Simd::from_array([-5, -4, -3, -2]);
let result = Simd::gather_or(&vec, idxs, alt); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([-5, 13, 10, 15]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)SIMD gather: construct a SIMD vector by reading from a slice, using potentially discontiguous indices. Out-of-bounds indices instead use the default value for that lane (0).
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);
let result = Simd::gather_or_default(&vec, idxs); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([0, 13, 10, 15]));pub fn gather_select(
slice: &[T],
mask: Mask<isize, LANES>,
idxs: Simd<usize, LANES>,
or: Self
) -> Self
🔬 This is a nightly-only experimental API. (portable_simd)
pub fn gather_select(
slice: &[T],
mask: Mask<isize, LANES>,
idxs: Simd<usize, LANES>,
or: Self
) -> Self
portable_simd)SIMD gather: construct a SIMD vector by reading from a slice, using potentially discontiguous indices. Out-of-bounds or masked indices instead select the value from the “or” vector.
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);
let alt = Simd::from_array([-5, -4, -3, -2]);
let mask = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.
let result = Simd::gather_select(&vec, mask, idxs, alt); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)SIMD scatter: write a SIMD vector’s values into a slice, using potentially discontiguous indices.
Out-of-bounds indices are not written.
scatter writes “in order”, so if an index receives two writes, only the last is guaranteed.
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]);
let vals = Simd::from_array([-27, 82, -41, 124]);
vals.scatter(&mut vec, idxs); // index 0 receives two writes.
assert_eq!(vec, vec![124, 11, 12, 82, 14, 15, 16, 17, 18]);🔬 This is a nightly-only experimental API. (portable_simd)
portable_simd)SIMD scatter: write a SIMD vector’s values into a slice, using potentially discontiguous indices.
Out-of-bounds or masked indices are not written.
scatter_select writes “in order”, so if an index receives two writes, only the last is guaranteed.
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]);
let vals = Simd::from_array([-27, 82, -41, 124]);
let mask = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.
vals.scatter_select(&mut vec, mask, idxs); // index 0's second write is masked, thus omitted.
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);Trait Implementations
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
impl<T, const LANES: usize> AsMut<[T; LANES]> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsMut<[T; LANES]> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsMut<[T]> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsMut<[T]> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsRef<[T; LANES]> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsRef<[T; LANES]> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsRef<[T]> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsRef<[T]> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> Binary for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Binary,
impl<T, const LANES: usize> Binary for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Binary,
impl<const LANES: usize> BitAndAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<&'_ usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<&'_ usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitAndAssign<usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitAndAssign<usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the &= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<&'_ usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<&'_ usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitOrAssign<usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitOrAssign<usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the |= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<&'_ usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<&'_ usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<i16> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<i32> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<i64> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<i8> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<isize> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<u16> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<u32> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<u64> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<u8> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<const LANES: usize> BitXorAssign<usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> BitXorAssign<usize> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
Performs the ^= operation. Read more
impl<T, const LANES: usize> Clone for Simd<T, LANES> where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Clone for Simd<T, LANES> where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Debug for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Debug,
impl<T, const LANES: usize> Debug for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Debug,
impl<T, const LANES: usize> Default for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Default,
impl<T, const LANES: usize> Default for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Default,
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
impl<T, const LANES: usize> From<[T; LANES]> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> From<[T; LANES]> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> From<Simd<T, LANES>> for [T; LANES] where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> From<Simd<T, LANES>> for [T; LANES] where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> Hash for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Hash,
impl<T, const LANES: usize> Hash for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Hash,
impl<I, T, const LANES: usize> Index<I> for Simd<T, LANES> where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
I: SliceIndex<[T]>,
impl<I, T, const LANES: usize> Index<I> for Simd<T, LANES> where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
I: SliceIndex<[T]>,
impl<I, T, const LANES: usize> IndexMut<I> for Simd<T, LANES> where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
I: SliceIndex<[T]>,
impl<I, T, const LANES: usize> IndexMut<I> for Simd<T, LANES> where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
I: SliceIndex<[T]>,
impl<T, const LANES: usize> LowerExp for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + LowerExp,
impl<T, const LANES: usize> LowerExp for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + LowerExp,
impl<T, const LANES: usize> LowerHex for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + LowerHex,
impl<T, const LANES: usize> LowerHex for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + LowerHex,
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
Performs the *= operation. Read more
impl<T, const LANES: usize> Octal for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Octal,
impl<T, const LANES: usize> Octal for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Octal,
impl<T, const LANES: usize> Ord for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Ord,
impl<T, const LANES: usize> Ord for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Ord,
impl<T, const LANES: usize> PartialEq<Simd<T, LANES>> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialEq,
impl<T, const LANES: usize> PartialEq<Simd<T, LANES>> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialEq,
impl<T, const LANES: usize> PartialOrd<Simd<T, LANES>> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialOrd,
impl<T, const LANES: usize> PartialOrd<Simd<T, LANES>> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialOrd,
This method returns an ordering between self and other values if one exists. Read more
This method tests less than (for self and other) and is used by the < operator. Read more
This method tests less than or equal to (for self and other) and is used by the <=
operator. Read more
This method tests greater than (for self and other) and is used by the > operator. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the %= operation. Read more
impl<T, const LANES: usize> Select<Mask<<T as SimdElement>::Mask, LANES>> for Simd<T, LANES> where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Select<Mask<<T as SimdElement>::Mask, LANES>> for Simd<T, LANES> where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the <<= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the >>= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
impl<T, const LANES: usize> UpperExp for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + UpperExp,
impl<T, const LANES: usize> UpperExp for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + UpperExp,
impl<T, const LANES: usize> UpperHex for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + UpperHex,
impl<T, const LANES: usize> UpperHex for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + UpperHex,
impl<T, const LANES: usize> Copy for Simd<T, LANES> where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Eq for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Eq,
Auto Trait Implementations
impl<T, const LANES: usize> RefUnwindSafe for Simd<T, LANES> where
T: RefUnwindSafe,
impl<T, const LANES: usize> UnwindSafe for Simd<T, LANES> where
T: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more